home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / THINKC / 4_0 / DONALDXC / XCMDGLUE.C < prev   
Text File  |  1990-05-01  |  13KB  |  557 lines
  1. /************************************/
  2. /* File: XCMDGlue.c                    */
  3. /*                                    */
  4. /* Callback routines for XCMDs        */
  5. /* and XFCNs.  This file should     */
  6. /* be included in your project        */
  7. /*                                    */
  8. /* Based on original work by        */
  9. /* Dan Winkler of Apple Computer    */
  10. /*                                    */
  11. /************************************/
  12.  
  13.  
  14. #include    <MacTypes.h>
  15. #include    <OSUtil.h>
  16. #include    <MemoryMgr.h>
  17. #include    <FileMgr.h>
  18. #include    <ResourceMgr.h>
  19. #include     "HyperXCmd.h"
  20. #include    <math.h>
  21.  
  22.  
  23. pascal void SendCardMessage(paramPtr,msg)
  24.     XCmdBlockPtr    paramPtr;    
  25.     char             *msg;
  26. /***********************
  27. * Send a message back to 
  28. * hypercard.  The input message
  29. * is a Pascal String
  30. ***********************/
  31. {
  32.     paramPtr->inArgs[0] = (long)msg;
  33.     paramPtr->request     = xreqSendCardMessage;
  34.     CallPascal( paramPtr->entryPoint );
  35. }
  36.  
  37.  
  38. pascal Handle EvalExpr(paramPtr,expr)
  39.     XCmdBlockPtr    paramPtr;    
  40.     char             *expr;
  41. /***********************
  42. * Evaluate a Hypertalk expression
  43. * returning the result as a "C" 
  44. * string
  45. ***********************/
  46. {
  47.     paramPtr->inArgs[0] = (long)expr;
  48.     paramPtr->request     = xreqEvalExpr;
  49.     CallPascal( paramPtr->entryPoint );
  50.     return (Handle)paramPtr->outArgs[0];
  51. }
  52.  
  53. pascal long StringLength(paramPtr,strPtr)
  54.     XCmdBlockPtr    paramPtr;
  55.     char             *strPtr;
  56. /***********************
  57. * Counts the number of 
  58. * characters in the input 
  59. * string from StrPtr to end
  60. * of string (zero byte)
  61. ***********************/
  62. {
  63.     paramPtr->inArgs[0] = (long)strPtr;
  64.     paramPtr->request     = xreqStringLength;
  65.     CallPascal( paramPtr->entryPoint );
  66.     return (long)paramPtr->outArgs[0];
  67. }
  68.  
  69.  
  70. pascal Ptr StringMatch(paramPtr,pattern,target)
  71.     XCmdBlockPtr    paramPtr;    
  72.     char             *pattern;
  73.     Ptr                target;
  74. /***********************
  75. * Case-insensitive match 
  76. * for pattern anywhere in
  77. * target, 
  78. * 
  79. * Returns a pointer to first
  80. * character of the first match,
  81. * in target or NIL if no match
  82. * found.  pattern is a Pascal string,
  83. * and target is a zero-terminated string.
  84. ***********************/
  85. {
  86.     paramPtr->inArgs[0] = (long)pattern;
  87.     paramPtr->inArgs[1] = (long)target;
  88.     paramPtr->request     = xreqStringMatch;
  89.     CallPascal( paramPtr->entryPoint );
  90.     return (Ptr)paramPtr->outArgs[0];
  91. }
  92.  
  93.  
  94. pascal void ZeroBytes(paramPtr,dstPtr,longCount)
  95.     XCmdBlockPtr    paramPtr;    
  96.     Ptr                dstPtr;    
  97.     long            longCount;
  98. /***********************
  99. * Clear memory starting at destPtr
  100. * through destPtr+longCount
  101. ***********************/
  102. {
  103.     paramPtr->inArgs[0] = (long)dstPtr;
  104.     paramPtr->inArgs[1] = longCount;
  105.     paramPtr->request     = xreqZeroBytes;
  106.     CallPascal( paramPtr->entryPoint );
  107. }
  108.  
  109.  
  110. pascal Handle PasToZero(paramPtr,pasStr)
  111.     XCmdBlockPtr    paramPtr;
  112.     char             *pasStr;
  113. /***********************
  114. * Convert a Pascal string (STR255)
  115. * to a zero-terminated string.  
  116. * Returns a handle to a zero-terminated
  117. * string.  The caller must dispose the handle.
  118. *
  119. * Useful for setting the result or
  120. * an argument you send from 
  121. * an XCMD to HyperTalk.
  122. ***********************/
  123. {
  124.     paramPtr->inArgs[0] = (long)pasStr;
  125.     paramPtr->request     = xreqPasToZero;
  126.     CallPascal( paramPtr->entryPoint );
  127.     return (Handle)paramPtr->outArgs[0];
  128. }
  129.  
  130. pascal void ZeroToPas(paramPtr,zeroStr,pasStr)
  131.     XCmdBlockPtr    paramPtr;    
  132.     char            *zeroStr;    
  133.     char             *pasStr;
  134. /***********************
  135. * Copy the zero-terminated
  136. * string into the Pascal String.
  137. *
  138. * You create the Pascal string 
  139. * and pass it by reference.
  140. *
  141. ***********************/
  142. {
  143.     paramPtr->inArgs[0] = (long)zeroStr;
  144.     paramPtr->inArgs[1] = (long)pasStr;
  145.     paramPtr->request     = xreqZeroToPas;
  146.     CallPascal( paramPtr->entryPoint );
  147. }
  148.  
  149.  
  150. pascal long StrToLong(paramPtr,strPtr)
  151.     XCmdBlockPtr    paramPtr;    
  152.     char             *strPtr;
  153. /***********************
  154. * Convert a string of ASCII
  155. * characters to an unsigned 
  156. * long integer.
  157. ***********************/
  158. {
  159.     paramPtr->inArgs[0] = (long)strPtr;
  160.     paramPtr->request     = xreqStrToLong;
  161.     CallPascal( paramPtr->entryPoint );
  162.     return (long)paramPtr->outArgs[0];
  163. }
  164.  
  165. pascal long StrToNum(paramPtr,str)
  166.     XCmdBlockPtr    paramPtr;    
  167.     char             *str;
  168. /***********************
  169. * Convert a string of ASCII
  170. * characters to a signed 
  171. * long integer.
  172. ***********************/
  173. {
  174.     paramPtr->inArgs[0] = (long)str;
  175.     paramPtr->request     = xreqStrToNum;
  176.     CallPascal( paramPtr->entryPoint );
  177.     return paramPtr->outArgs[0];
  178. }
  179.  
  180.  
  181. pascal Boolean StrToBool(paramPtr,str)
  182.     XCmdBlockPtr    paramPtr;
  183.     char             *str;
  184. /***********************
  185. * Convert the Pascal strings
  186. * 'true' and 'false' to booleans.
  187. ***********************/
  188. {
  189.     paramPtr->inArgs[0] = (long)str;
  190.     paramPtr->request     = xreqStrToBool;
  191.     CallPascal( paramPtr->entryPoint );
  192.     return (Boolean)paramPtr->outArgs[0];
  193. }
  194.  
  195.  
  196. pascal void StrToExt(paramPtr,str,myext)
  197.     XCmdBlockPtr    paramPtr;
  198.     char             *str;    
  199.     char             *myext;
  200. /***********************
  201. * Convert a string of ASCII digits 
  202. * to an extended long integer.
  203. *
  204. * The return value is passed
  205. * by reference and you must
  206. * asllocate the space before 
  207. * calling this routine.
  208. ***********************/
  209. {
  210.     paramPtr->inArgs[0] = (long)str;
  211.     paramPtr->inArgs[1] = (long)myext;
  212.     paramPtr->request     = xreqStrToExt;
  213.     CallPascal( paramPtr->entryPoint );
  214. }
  215.  
  216.  
  217. pascal void LongToStr(paramPtr,posNum,mystr)
  218.     XCmdBlockPtr    paramPtr;    
  219.     long             posNum;    
  220.     char             *mystr;
  221. /***********************
  222. * Convert an unsigned long integer
  223. * to a pascal string representation
  224. * Useful for sending numbers back 
  225. * to Hypercard.
  226. *
  227. *  You create mystr and pass
  228. * it by reference.
  229. ***********************/
  230. {
  231.     paramPtr->inArgs[0] = (long)posNum;
  232.     paramPtr->inArgs[1] = (long)mystr;
  233.     paramPtr->request     = xreqLongToStr;
  234.     CallPascal( paramPtr->entryPoint );
  235. }
  236.  
  237.  
  238. pascal void NumToStr(paramPtr,num,mystr)
  239.     XCmdBlockPtr    paramPtr;    
  240.     long             num;    
  241.     char             *mystr;
  242. /***********************
  243. * Convert a signed long integer
  244. * to a pascal string representation
  245. * Useful for sending numbers back 
  246. * to Hypercard.
  247. *
  248. *  You create mystr and pass
  249. * it by reference.
  250. ***********************/
  251. {
  252.     paramPtr->inArgs[0] = num;
  253.     paramPtr->inArgs[1] = (long)mystr;
  254.     paramPtr->request     = xreqNumToStr;
  255.     CallPascal( paramPtr->entryPoint );
  256. }
  257.  
  258.  
  259. pascal void NumToHex(paramPtr,num,nDigits,mystr)
  260.     XCmdBlockPtr    paramPtr;    
  261.     long             num;
  262.     short            nDigits;            
  263.     char             *mystr;
  264. /***********************
  265. * Convert an unsigned long integer
  266. * to a hexadecimal number and put it
  267. * into a Pascal string.
  268. *
  269. * The "output" string is passed
  270. * by reference.
  271. ***********************/
  272. {
  273.     paramPtr->inArgs[0] = num;
  274.     paramPtr->inArgs[1] = nDigits;
  275.     paramPtr->inArgs[2] = (long)mystr;
  276.     paramPtr->request     = xreqNumToHex;
  277.     CallPascal( paramPtr->entryPoint );
  278. }
  279.  
  280.  
  281. pascal void BoolToStr(paramPtr,bool,mystr)
  282.     XCmdBlockPtr    paramPtr;    
  283.     Boolean            bool;    
  284.     char             *mystr;
  285. /***********************
  286. * Convert a boolean to 
  287. * 'true' or 'false'.  
  288. *
  289. * The "output" string is passed
  290. * by reference.
  291. ***********************/
  292. {
  293.     paramPtr->inArgs[0] = (long)bool;
  294.     paramPtr->inArgs[1] = (long)mystr;
  295.     paramPtr->request     = xreqBoolToStr;
  296.     CallPascal( paramPtr->entryPoint );
  297. }
  298.  
  299.  
  300. pascal void ExtToStr( paramPtr, myext, mystr)
  301.     XCmdBlockPtr    paramPtr;    
  302.     char             *myext;    
  303.     char             *mystr;
  304. /***********************
  305. * Convert an extended long
  306. * to its string representation
  307. *
  308. * The "output" string is passed
  309. * by reference.
  310. ***********************/
  311. {
  312.     paramPtr->inArgs[0] = (long)myext;
  313.     paramPtr->inArgs[1] = (long)mystr;
  314.     paramPtr->request     = xreqExtToStr;
  315.     CallPascal( paramPtr->entryPoint );
  316. }
  317.  
  318.  
  319. pascal Handle GetGlobal(paramPtr,globName)
  320.     XCmdBlockPtr    paramPtr;    
  321.     char             *globName;
  322. /***********************
  323. * Return a handle to a zero-terminated
  324. * string containing the value of 
  325. * the specified HyperTalk global variable.
  326. ***********************/
  327. {
  328.     paramPtr->inArgs[0] = (long)globName;
  329.     paramPtr->request     = xreqGetGlobal;
  330.     CallPascal( paramPtr->entryPoint );
  331.     return (Handle)paramPtr->outArgs[0];
  332. }
  333.  
  334. pascal void SetGlobal(paramPtr,globName,globValue)
  335.     XCmdBlockPtr    paramPtr;    
  336.     char             *globName;    
  337.     Handle            globValue;
  338. /***********************
  339. * Set the value of the specified 
  340. * HyperTalk global variable to be
  341. * the zero-terminated string in globValue.
  342. * The contents of globValue
  343. * are copied, you dispose the
  344. * handle
  345. ***********************/
  346. {
  347.     paramPtr->inArgs[0] = (long)globName;
  348.     paramPtr->inArgs[1] = (long)globValue;
  349.     paramPtr->request     = xreqSetGlobal;
  350.     CallPascal( paramPtr->entryPoint );
  351. }
  352.  
  353.  
  354. pascal Handle GetFieldByName(paramPtr,cardFieldFlag,fieldName)
  355.     XCmdBlockPtr    paramPtr;    
  356.     Boolean            cardFieldFlag;
  357.     char             *fieldName;
  358. /***********************
  359. * Return a handle to a zero-terminated
  360. * string containing the value of 
  361. * field fieldName on the current 
  362. * card.  You must dispose the handle.
  363. *
  364. * Set cardfieldFlag to ture if
  365. * you want the contents of a card
  366. * field or to false if you want
  367. * the contents of a bkgnd field
  368. ***********************/
  369. {
  370.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  371.     paramPtr->inArgs[1] = (long)fieldName;
  372.     paramPtr->request     = xreqGetFieldByName;
  373.     CallPascal( paramPtr->entryPoint );
  374.     return (Handle)paramPtr->outArgs[0];
  375. }
  376.  
  377.  
  378. pascal Handle GetFieldByNum(paramPtr,cardFieldFlag,fieldNum)
  379.     XCmdBlockPtr    paramPtr;    
  380.     Boolean            cardFieldFlag;
  381.     short            fieldNum;
  382. /***********************
  383. * Returns a copy of the contents
  384. * of the field whose number is
  385. * fieldnum on the current
  386. * card.
  387. *
  388. * You dispose the handle when
  389. * you are done.
  390. ***********************/
  391. {
  392.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  393.     paramPtr->inArgs[1] = fieldNum;
  394.     paramPtr->request     = xreqGetFieldByNum;
  395.     CallPascal( paramPtr->entryPoint );
  396.     return (Handle)paramPtr->outArgs[0];
  397. }
  398.  
  399.  
  400. pascal Handle GetFieldByID(paramPtr,cardFieldFlag,fieldID)
  401.     XCmdBlockPtr    paramPtr;    
  402.     Boolean            cardFieldFlag;
  403.     short            fieldID;
  404. /***********************
  405. * Returns a copy of the contents
  406. * of the field whose id is
  407. * fieldID on the current
  408. * card.
  409. *
  410. * You dispose the handle when
  411. * you are done.
  412. ***********************/
  413. {
  414.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  415.     paramPtr->inArgs[1] = fieldID;
  416.     paramPtr->request     = xreqGetFieldByID;
  417.     CallPascal( paramPtr->entryPoint );
  418.     return (Handle)paramPtr->outArgs[0];
  419. }
  420.  
  421.  
  422. pascal void SetFieldByName(paramPtr,cardFieldFlag,fieldName,fieldVal)
  423.     XCmdBlockPtr    paramPtr;    
  424.     Boolean            cardFieldFlag;
  425.     char             *fieldName;    
  426.     Handle            fieldVal;
  427. /***********************
  428. * Set the value of the field 
  429. * whose name is fieldName on
  430. * the current card.
  431. *
  432. * You dispose the handle when
  433. * you are done.
  434. ***********************/
  435. {
  436.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  437.     paramPtr->inArgs[1] = (long)fieldName;
  438.     paramPtr->inArgs[2] = (long)fieldVal;
  439.     paramPtr->request     = xreqSetFieldByName;
  440.     CallPascal( paramPtr->entryPoint );
  441. }
  442.  
  443.  
  444. pascal void SetFieldByNum(paramPtr,cardFieldFlag,fieldNum,fieldVal)
  445.     XCmdBlockPtr    paramPtr;    
  446.     Boolean            cardFieldFlag;
  447.     short            fieldNum;            
  448.     Handle            fieldVal;
  449. /***********************
  450. * Set the value of the field 
  451. * whose number is fieldnum on
  452. * the current card.
  453. *
  454. * You dispose the handle when
  455. * you are done.
  456. ***********************/
  457. {
  458.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  459.     paramPtr->inArgs[1] = fieldNum;
  460.     paramPtr->inArgs[2] = (long)fieldVal;
  461.     paramPtr->request     = xreqSetFieldByNum;
  462.     CallPascal( paramPtr->entryPoint );
  463. }
  464.  
  465.  
  466. pascal void SetFieldByID(paramPtr,cardFieldFlag,fieldID,fieldVal)
  467.     XCmdBlockPtr    paramPtr;    
  468.     Boolean            cardFieldFlag;
  469.     short            fieldID;            
  470.     Handle            fieldVal;
  471. /***********************
  472. * Set the value of the field 
  473. * whose id is fieldID on
  474. * the current card.
  475. *
  476. * You dispose the handle when
  477. * you are done.
  478. ***********************/
  479. {
  480.     paramPtr->inArgs[0] = (long)cardFieldFlag;
  481.     paramPtr->inArgs[1] = fieldID;
  482.     paramPtr->inArgs[2] = (long)fieldVal;
  483.     paramPtr->request     = xreqSetFieldByID;
  484.     CallPascal( paramPtr->entryPoint );
  485. }
  486.  
  487.  
  488. pascal Boolean StringEqual(paramPtr,str1,str2)
  489.     XCmdBlockPtr    paramPtr;    
  490.     char            *str1;    
  491.     char             *str2;
  492. /***********************
  493. * Returns true if the strings
  494. * match, false otherwise.
  495. * 
  496. * Compare is case insensitive
  497. ***********************/
  498. {
  499.     paramPtr->inArgs[0] = (long)str1;
  500.     paramPtr->inArgs[1] = (long)str2;
  501.     paramPtr->request     = xreqStringEqual;
  502.     CallPascal( paramPtr->entryPoint );
  503.     return (Boolean)paramPtr->outArgs[0];
  504. }
  505.  
  506.  
  507. pascal void ReturnToPas(paramPtr,zeroStr,pasStr)
  508.     XCmdBlockPtr    paramPtr;    
  509.     Ptr                zeroStr;    
  510.     char             *pasStr;
  511. /***********************
  512. * Collect characters from zeroStr
  513. * to the next carriage Return and return 
  514. * them in the Pascal string pasStr. 
  515. * 
  516. * If no Return found, collect chars
  517. * until the end of the string (zero)
  518. ***********************/
  519. {
  520.     paramPtr->inArgs[0] = (long)zeroStr;
  521.     paramPtr->inArgs[1] = (long)pasStr;
  522.     paramPtr->request     = xreqReturnToPas;
  523.     CallPascal( paramPtr->entryPoint );
  524. }
  525.  
  526.  
  527. pascal void ScanToReturn(paramPtr,scanHndl)
  528.     XCmdBlockPtr    paramPtr;    
  529.     Ptr             *scanHndl;
  530. /***********************
  531. * Position the pointer, scanPtr,
  532. * at a Return character
  533. * or a zero byte. 
  534. ***********************/
  535. {
  536.     paramPtr->inArgs[0] = (long)scanHndl;
  537.     paramPtr->request     = xreqScanToReturn;
  538.     CallPascal( paramPtr->entryPoint );
  539. }
  540.  
  541.  
  542. pascal void ScanToZero(paramPtr,scanHndl)
  543.     XCmdBlockPtr    paramPtr;    
  544.     Ptr             *scanHndl;
  545. /***********************
  546. * Position the pointer, scanPtr,
  547. * at a  zero byte. 
  548. ***********************/
  549. {
  550.     paramPtr->inArgs[0] = (long)scanHndl;
  551.     paramPtr->request     = xreqScanToZero;
  552.     CallPascal( paramPtr->entryPoint );
  553. }
  554.  
  555.  
  556.  
  557.